ATOM Documentation

CREATE TABLE oauth_states (
  id VARCHAR PRIMARY KEY,
  tenant_id VARCHAR NOT NULL REFERENCES tenants(id) ON DELETE CASCADE,
  user_id VARCHAR REFERENCES users(id) ON DELETE CASCADE,
  state VARCHAR UNIQUE NOT NULL,
  provider VARCHAR NOT NULL,
  expires_at TIMESTAMPTZ NOT NULL,
  created_at TIMESTAMPTZ DEFAULT NOW(),
  redirect_uri VARCHAR,
  extra_data JSON
);

CREATE TABLE integration_tokens (
  id VARCHAR PRIMARY KEY,
  tenant_id VARCHAR NOT NULL REFERENCES tenants(id) ON DELETE CASCADE,
  user_id VARCHAR REFERENCES users(id) ON DELETE CASCADE,
  workspace_id VARCHAR REFERENCES workspaces(id) ON DELETE SET NULL,
  provider VARCHAR NOT NULL,
  access_token TEXT NOT NULL,
  refresh_token TEXT,
  token_type VARCHAR DEFAULT 'Bearer',
  expires_at TIMESTAMPTZ,
  instance_url TEXT,
  scope TEXT,
  status VARCHAR DEFAULT 'active',
  created_at TIMESTAMPTZ DEFAULT NOW(),
  updated_at TIMESTAMPTZ DEFAULT NOW(),
  UNIQUE(tenant_id, provider, user_id)
);

import { getDatabase } from '@/lib/db';

export interface {Provider}Tokens {
  access_token: string;
  refresh_token?: string;
  // ... provider-specific fields
}

export class {Provider}Client {
  private tenantId: string;
  private userId?: string;
  private tokens: {Provider}Tokens | null = null;

  constructor(tenantId: string, userId?: string) {
    this.tenantId = tenantId;
    this.userId = userId;
  }

  // OAuth URL generation
  static getAuthUrl(state: string, scopes?: string[]): string {
    const config = getConfig();
    const params = new URLSearchParams({
      client_id: config.clientId,
      redirect_uri: config.redirectUri,
      response_type: 'code',
      scope: scopes.join(' '),
      state,
    });
    return `{AUTH_URL}?${params}`;
  }

  // Token exchange
  static async exchangeCode(code: string): Promise<{Provider}Tokens> {
    const config = getConfig();
    const response = await fetch(`{TOKEN_URL}`, {
      method: 'POST',
      body: new URLSearchParams({
        grant_type: 'authorization_code',
        client_id: config.clientId,
        client_secret: config.clientSecret,
        redirect_uri: config.redirectUri,
        code,
      }),
    });
    return response.json();
  }

  // Load from database
  async loadTokens(): Promise<boolean> {
    const db = getDatabase();
    const result = await db.query(
      `SELECT access_token, refresh_token FROM integration_tokens
       WHERE tenant_id = $1 AND provider = '{provider}'
       AND status = 'active' LIMIT 1`,
      [this.tenantId]
    );
    if (result.rows.length === 0) return false;
    this.tokens = result.rows[0];
    return true;
  }

  // Save to database
  async saveTokens(tokens: {Provider}Tokens): Promise<void> {
    const db = getDatabase();
    await db.query(
      `INSERT INTO integration_tokens (tenant_id, provider, access_token, refresh_token, status)
       VALUES ($1, '{provider}', $2, $3, 'active')
       ON CONFLICT (tenant_id, provider)
       DO UPDATE SET access_token = EXCLUDED.access_token,
         refresh_token = COALESCE(EXCLUDED.refresh_token, integration_tokens.refresh_token),
         updated_at = NOW()`,
      [this.tenantId, tokens.access_token, tokens.refresh_token]
    );
  }

  // Provider-specific API methods
  async getItems(): Promise<any[]> { /* ... */ }
}

{
  "authUrl": "https://provider.com/oauth/authorize?...",
  "state": "random_state_token"
}

{
  "connected": true,
  "connection": {
    "id": "token_id",
    "scope": "read_write",
    "connected_at": "2025-02-01T00:00:00Z",
    "updated_at": "2025-02-01T00:00:00Z"
  }
}

{
  "success": true,
  "message": "{Provider} disconnected"
}

import { createActivepiecesAdapter } from '@/lib/integrations/activepieces-adapter';

const adapter = createActivepiecesAdapter(tenantId, userId);

// Execute any piece
const result = await adapter.executePiece({
  pieceId: 'discord',
  action: 'send_message',
  config: { webhook_url: '...' },
  input: { content: 'Hello from ATOM!' },
});

// List available integrations
const pieces = adapter.listPieces('communication');

// Search integrations
const results = adapter.searchPieces('crm');

# OAuth2 Integrations
{PROVIDER}_CLIENT_ID=""
{PROVIDER}_CLIENT_SECRET=""
{PROVIDER}_REDIRECT_URI="https://your-domain.com/api/integrations/{provider}/callback"

# API Key Integrations
{PROVIDER}_API_KEY=""

STRIPE_CLIENT_ID="ca_..."
STRIPE_CLIENT_SECRET="sk_..."
STRIPE_REDIRECT_URI="https://atom.ai/api/integrations/stripe/callback"

AIRTABLE_API_KEY="pat_..."

// ✅ CORRECT - Multi-tenant
const db = getDatabase();
const result = await db.query(
  `SELECT * FROM integration_tokens
   WHERE tenant_id = $1 AND provider = $2`,
  [tenantId, provider]
);

// ❌ WRONG - Missing tenant filter
const result = await db.query(
  `SELECT * FROM integration_tokens
   WHERE provider = $1`,
  [provider]
);

private async request<T>(endpoint: string): Promise<T> {
  // Load tokens
  if (!this.tokens) await this.loadTokens();

  // Check if expired
  if (this.tokens.expires_at) {
    const expiresAt = new Date(this.tokens.expires_at);
    if (Date.now() >= expiresAt.getTime() && this.tokens.refresh_token) {
      // Refresh token
      this.tokens = await {Provider}Client.refreshAccessToken(this.tokens.refresh_token);
      await this.saveTokens(this.tokens);
    }
  }

  // Make request
  return fetch(url, {
    headers: { Authorization: `Bearer ${this.tokens.access_token}` },
  });
}

npm run generate:integration -- --provider stripe --auth oauth2
npm run generate:integration -- --provider airtable --auth api_key
npm run generate:integration -- --provider figma --auth basic

# 1. Start dev server
npm run dev

# 2. Navigate to /integrations

# 3. Click "Connect {Provider}"

# 4. Complete OAuth flow in provider popup

# 5. Verify redirect with ?success={provider}

# 6. Check database
psql $DATABASE_URL -c "SELECT * FROM integration_tokens WHERE provider = '{provider}'"

const client = new StripeClient(tenantId);
await client.loadTokens();
const balance = await client.getBalance();
console.log(balance);

CREATE POLICY integration_tokens_tenant_isolation
ON integration_tokens
FOR ALL
USING (tenant_id = current_setting('app.current_tenant_id')::UUID);

GET /api/integrations/status

{
  "total_integrations": 569,
  "native_implementations": 19,
  "connected": 8,
  "categories": 9,
  "providers": [
    {
      "id": "slack",
      "name": "Slack",
      "connected": true,
      "status": "active"
    },
    // ...
  ]
}